package versionAscensor;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.IOException;

import javax.swing.Timer;

public class ClaseDeControl
{
	/**
	 * Definicion de variables y constantes a utilizar
	 */

	DetectarPuerto Detecto = new DetectarPuerto(); // instancia de Class
											       // Detectar Puerto

	// puertos detectados
	int[] DireccionArduino = new int[20]; // Contiene la direccion que responde
										  // el Arduino en el puerto
	/**
	 * Instancias de las distintas clases
	 */
	LeerArchivoConfiguracion Lectura = new LeerArchivoConfiguracion(); // Para
																		// leer
																		// los
																		// datos
																		// del
																		// archivo
																		// de
																		// configuracion
	LecturaArchivoVincularSalidas LecturaSalidas = new LecturaArchivoVincularSalidas();
	
	CreacionEscrituraArchivoLog EscribirLog = new CreacionEscrituraArchivoLog();
	
	String[] PuertoEncontrado = new String[20]; // contiene los string de los
	// puerto
	ComunicacionSerie PuertoTemporal = new ComunicacionSerie(); // instancia de
	// ComunicacionSerie
	// Se usa
	// temporalmente
	// para detectar
	// que
	// placa esta
	// conectada a
	// que puerto

	ComunicacionSerie Primero = new ComunicacionSerie(); // instancia de
	// ComunicacionSerie

	boolean PrimerPuertoAbierto = false; // Flag que indica que se inicio un


	ComunicacionSerie Segundo = new ComunicacionSerie(); // instancia de
															// ComunicacionSerie
	boolean SegundoPuertoAbierto = false;

	ComunicacionSerie Tercero = new ComunicacionSerie(); // instancia de
															// ComunicacionSerie
	boolean TercerPuertoAbierto = false;

//	NuevaVentana Ventana = null;
	Timer timer = null;
	Timer Respuesta = null;
	Timer timerdesconeccion = null;
	/**
	 * Lectura de Variables de configuracion de parametros para la conexion por
	 * USB
	 */

	String BaudRate = Lectura.LeerArchivoConfig("baudrate");
	String Bitsdatos = Lectura.LeerArchivoConfig("bitsdatos");
	String Bitsparada = Lectura.LeerArchivoConfig("bitsparada");
	String Paridad = Lectura.LeerArchivoConfig("paridad");

	/**
	 * Lectura de Variables de configuracion general.
	 */

	int CantidadArduinos = Integer.valueOf(Lectura.LeerArchivoConfig("cantiArduinos"));
	int CantidadPisosARD1 = Integer.valueOf(Lectura.LeerArchivoConfig("cantpisosArd1"));
	int CantidadPisosARD2 = Integer.valueOf(Lectura.LeerArchivoConfig("cantpisosArd2"));
	int CantidadPisosARD3 = Integer.valueOf(Lectura.LeerArchivoConfig("cantpisosArd3"));
	int CantidadPlacasARD1 = Integer.valueOf(Lectura.LeerArchivoConfig("cantplacaArduino1"));
	int CantidadPlacasARD2 = Integer.valueOf(Lectura.LeerArchivoConfig("cantplacaArduino2"));
	int CantidadPlacasARD3 = Integer.valueOf(Lectura.LeerArchivoConfig("cantplacaArduino3"));
	int CantidadTotalPisos = Integer.valueOf(Lectura.LeerArchivoConfig("cantpisos"));
	int SalidaBotonAbrirPuerta = Integer.valueOf(Lectura.LeerArchivoConfig("SalAbrirPuerta"));
	int SalidaBotonCerrarPuerta = Integer.valueOf(Lectura.LeerArchivoConfig("SalCerrarPuerta"));
	
	int ValorComparacion = Integer.valueOf(Lectura.LeerArchivoConfig("ValorComparacion"));
	
	/**
	 * Variables para los botones de los pisos de acceso directo
	 */
	String	LabelBotonpisodirecto1 = Lectura.LeerArchivoConfig("LabelBotonpisodirecto1");
	String	LabelBotonpisodirecto2 = Lectura.LeerArchivoConfig("LabelBotonpisodirecto2");
	String	LabelBotonpisodirecto3 = Lectura.LeerArchivoConfig("LabelBotonpisodirecto3");
	String	LabelBotonpisodirecto4 = Lectura.LeerArchivoConfig("LabelBotonpisodirecto4");
	String	LabelBotonpisodirecto5 = Lectura.LeerArchivoConfig("LabelBotonpisodirecto5");
	String	LabelBotonpisodirecto6 = Lectura.LeerArchivoConfig("LabelBotonpisodirecto6");
	String	LabelBotonpisodirecto7 = Lectura.LeerArchivoConfig("LabelBotonpisodirecto7");
	String	LabelBotonpisodirecto8 = Lectura.LeerArchivoConfig("LabelBotonpisodirecto8");
	String	LabelBotonpisodirecto9 = Lectura.LeerArchivoConfig("LabelBotonpisodirecto9");
	
	String	LabelCortopisodirecto1 = Lectura.LeerArchivoConfig("LabelCortopisodirecto1");
	String	LabelCortopisodirecto2 = Lectura.LeerArchivoConfig("LabelCortopisodirecto2");
	String	LabelCortopisodirecto3 = Lectura.LeerArchivoConfig("LabelCortopisodirecto3");
	String	LabelCortopisodirecto4 = Lectura.LeerArchivoConfig("LabelCortopisodirecto4");
	String	LabelCortopisodirecto5 = Lectura.LeerArchivoConfig("LabelCortopisodirecto5");
	String	LabelCortopisodirecto6 = Lectura.LeerArchivoConfig("LabelCortopisodirecto6");
	String	LabelCortopisodirecto7 = Lectura.LeerArchivoConfig("LabelCortopisodirecto7");
	String	LabelCortopisodirecto8 = Lectura.LeerArchivoConfig("LabelCortopisodirecto8");
	String	LabelCortopisodirecto9 = Lectura.LeerArchivoConfig("LabelCortopisodirecto9");
	
	
	int	SalidaBotonpisodirecto1 = Integer.valueOf(Lectura.LeerArchivoConfig("SalidaBotonpisodirecto1"));
	int	SalidaBotonpisodirecto2 = Integer.valueOf(Lectura.LeerArchivoConfig("SalidaBotonpisodirecto2"));
	int	SalidaBotonpisodirecto3 = Integer.valueOf(Lectura.LeerArchivoConfig("SalidaBotonpisodirecto3"));
	int	SalidaBotonpisodirecto4 = Integer.valueOf(Lectura.LeerArchivoConfig("SalidaBotonpisodirecto4"));
	int	SalidaBotonpisodirecto5 = Integer.valueOf(Lectura.LeerArchivoConfig("SalidaBotonpisodirecto5"));
	int	SalidaBotonpisodirecto6 = Integer.valueOf(Lectura.LeerArchivoConfig("SalidaBotonpisodirecto6"));
	int	SalidaBotonpisodirecto7 = Integer.valueOf(Lectura.LeerArchivoConfig("SalidaBotonpisodirecto7"));
	int	SalidaBotonpisodirecto8 = Integer.valueOf(Lectura.LeerArchivoConfig("SalidaBotonpisodirecto8"));
	int	SalidaBotonpisodirecto9 = Integer.valueOf(Lectura.LeerArchivoConfig("SalidaBotonpisodirecto9"));
	
	
	
	
	
	// int retardo = Integer.valueOf(Lectura.LeerArchivoConfig("retinicio"));
	int periodo = Integer.valueOf(Lectura.LeerArchivoConfig("delams"));
	int periododesconeccion = Integer.valueOf(Lectura.LeerArchivoConfig("desconeccion"));

	int pos;
	int placa = 1; // Variable que controla el nro de placa a leer en el momento

	int Cont = 0;
	int Cont1 = 0;
	int Cont2 = 0;
	int Cont3 = 0;

	
	int[] PrimeroPiso = new int[16]; // Pisos elegidos en el ARDUINO 1
	int[] SegundoPiso = new int[16]; // Pisos elegidos en el ARDUINO 2
	int[] TerceroPiso = new int[16]; // Pisos elegidos en el ARDUINO 3
	int[] PisosElegidos = new int[205]; // Pisos elegidos en total

	int contadortimer = 0;
	int ultimasalida = 0;
	
	boolean FlagDatosAmostrarARD1 = false;
	boolean FlagDatosAmostrarARD2 = false;
	boolean FlagDatosAmostrarARD3 = false;
	boolean DatosAMostrar = false;
	
	boolean DesconeccionArduino = false;
	
	int	UbicacionAscensor = 0;
	int DireccionAscensor = 0;
	
	int[] VectorSalidas = new int [100];
	
	//Vector donde se almacenan las relaciones de Salida 
	
	// Timer timer = null;

	// -----------------------------------------------------------------------------------------------------------------------------------

	public static void main(String[] args) // Lo primero que se ejecuta.
	{
		new ClaseDeControl(); // LLamo a un nuevo contructor de la Clase
		// podria haber instanciado tambien.
		
	}

	public ClaseDeControl() // Constructor de la Clase
	{
		super();
		this.LeerconfiguracionVectorSalida();
	}

	public void Inicializacion() // Funcion que se encarga de Controlar todo
	{
		// System.out.println("Principal");
		// Ventana.main(null); // inicio la interfaz grafica
		
		//inicializacion del archivo donde se guardan
		//los logs del programa.
		try
		{
			EscribirLog.main(null);
		} catch (IOException e1)
		{
			// TODO Auto-generated catch block
			e1.printStackTrace();
		}
		EscribirLog.EscribirElArchivo("Iniciando Programa");
		/***
		 * trata de obtener el primer puerto USB Libre
		 * 
		 */
	//	EscribirLog.ModificarFechaAccesoArchivo();
		try
		{
			PuertoEncontrado = Detecto.getAvailableSerialPorts();
			pos = 0;
			while (PuertoEncontrado[pos] != null)
			{
				System.out
						.println("puerto Encontrado " + PuertoEncontrado[pos]);
				/***TODO
				*/
				EscribirLog.EscribirElArchivo("puerto Encontrado " + PuertoEncontrado[pos]);
				
				PuertoTemporal.Abrirpuerto(PuertoEncontrado[pos], BaudRate,
						Bitsdatos, Bitsparada, Paridad);// abro
														// el
														// puerto
														// en
														// cuestion
														// para
														// ver
														// que
														// dato
														// me
														// devuelve
														// la
														// placa
				PuertoTemporal.main(); // inicializo la escucha del
										// puerto serie
				Thread.sleep(2000);//2000);
				PuertoTemporal.EscribirPuerto("OR00"); // Solicito a
														// la placa
														// que me
														// diga su
														// direccion.
				//Thread.sleep(1000);//1000);
				PuertoTemporal.CerrarPuerto();// Cierro el puerto en
												// cuestion una vez
												// obtenido el dato
												// deseado.
				DireccionArduino[pos] = PuertoTemporal.getDireccionDetectada();
				// System.out.println("Direccion " +
				// DireccionArduino[pos]);
				++pos;
			}
			// DireccionArduino =
			for (int u = 0; u < pos; ++u)
			{
				if (DireccionArduino[u] != 0)
				{
					System.out.println("En el puerto USB "
							+ PuertoEncontrado[u]
							+ " Se encontro el Controlador "
							+ DireccionArduino[u]);
					/***TODO
					*/
					EscribirLog.EscribirElArchivo("En el puerto USB "
							+ PuertoEncontrado[u]
							+ " Se encontro el Controlador "
							+ DireccionArduino[u]);
				}
				if (DireccionArduino[u] == 1) // se conecta el
												// arduino 1 con la
												// primera instancia
				{
					Primero.Abrirpuerto(PuertoEncontrado[u], BaudRate,
							Bitsdatos, Bitsparada, Paridad);
					Primero.main();
					PrimerPuertoAbierto = true;
					Primero.ErrorComunicacion = false;
					Primero.TemporizadorArduino();
				//	Primero.IniciarTimerArduino();
				}
				if (DireccionArduino[u] == 2)// se conecta el
												// arduino 2 con la
												// segunda instancia
				{
					Segundo.Abrirpuerto(PuertoEncontrado[u], BaudRate,
							Bitsdatos, Bitsparada, Paridad);
					Segundo.main();
					SegundoPuertoAbierto = true;
					Segundo.ErrorComunicacion = false;
					Segundo.TemporizadorArduino();
				//	Segundo.IniciarTimerArduino();
				}
				if (DireccionArduino[u] == 3)// se conecta el
												// arduino 3 con la
												// tercera instancia
				{
					Tercero.Abrirpuerto(PuertoEncontrado[u], BaudRate,
							Bitsdatos, Bitsparada, Paridad);
					Tercero.main();
					TercerPuertoAbierto = true;
					Tercero.ErrorComunicacion = false;
				}
			}

			// una vez iniciado los puertos a usar
			// arrancar el Timer

			// Start(1);
			// IniciarTimer();

		} catch (Exception e)
		{
			e.printStackTrace();
		}// */

		/*this.Temporizador();
		this.TemporizadorRespuesta(150);
		/*
		 * Aca ya se termino de detectar todo los puertos y Arduinos conectados
		 * Por consiguiente se puede iniciar el timer de lectura para los
		 * distintos Arduinos y placas que contienen.
		 */
		// timer.start();
		/*
		 * while (!Ventana.VentanaCerrada) //mientras no se cierre la ventana {
		 * // System.out.println("while");
		 * 
		 * 
		 * 
		 * 
		 * }
		 * 
		 * System.out.println("Salida"); timer.stop(); // Detengo el timer de
		 * lectura. //finalize(); // Funcion que cierra todos los puertos y da
		 * salida. //
		 */
/**
 * Pueba de modificar la ultima fecha de acceso a archivo.
 */

	}

	// -------------------------------------------------------------------------------------------------------------------------------------
	/**
	 * Cierra todos los puertos que fueron abiertos
	 */
	protected void FinalizarPrograma()
	{
		// Cierro todos los puertos usados

		try
		{
			if (PrimerPuertoAbierto == true)
				Primero.CerrarPuerto();
			if (SegundoPuertoAbierto == true)
				Segundo.CerrarPuerto();
			if (TercerPuertoAbierto == true)
				Tercero.CerrarPuerto();
		} catch (Exception e)
		{
			e.printStackTrace();
		}
		System.exit(1);

	}

	// ------------------------------------------------------------------------------------------------------------------------------------
	/*
	 * Funciones que manejan el primer timer. Correspondiente al timer de
	 * Lectura de las placas
	 */
	/**
	 * Inicia el timer de Lectura de estado de los arduinos
	 */
	public void IniciarTimer()
	{
		timer.start();
	}

	/**
	 * Detiene el timer de Lectura detener el timer de los arduinos
	 */
	public void DetenerTimer()
	{
		timer.stop();
	}

	/**
	 * Timer de Lectura. realiza la solicitud de Lectura a cada Arduino
	 * Encontrado.
	 */
	public void Temporizador()
	{
		Cont = 0;
		Cont1 = 0;
		
		ActionListener Accion = new ActionListener()
		{
			
			/*
			 * El timer se emplea como un evento A continuacion se coloca el
			 * codigo a ser Realizado cada vez que se acciona el timer
			 */
			public void actionPerformed(ActionEvent e)
			{
							
				if (placa <= 1)
				{
					//Aca tengo que modificar para q tambien verifique si hay error
					//si llegara a haber error con un arduino,
					//no enviar mas dato
					//cerrar el puerto donde se encontraba el arduino
					//y tratar de volver a abrirlo
					
					
					if (Primero.ErrorComunicacion == true || Segundo.ErrorComunicacion == true || 
							Tercero.ErrorComunicacion == true )
						//si hubo algun error de comunincacion
						//se realiza esta operacion mientras no se 
						//detecten todos los arduinos que estaban 
						//en un  principio
					{
						//Primero.DetenerTimerArduino();
						//Segundo.DetenerTimerArduino();
						CerrarTodosPuertos();
						
						//Vuelvo a detectar los arduinos conectados
						Inicializacion();
						IniciarTimerDesconeccion();
						EscribirLog.EscribirElArchivo("Puerto USB Desconectado ");
					}
					else 
					//Si no hubo error de comunicacion
					//con ningun arduino						
					{	
						if (PrimerPuertoAbierto == true && Primero.ErrorComunicacion == false)
						{
							Primero.LeerPuerto();
							//inicio timer para la respuesta del Arduino 1
							//vuelvo a validad ErrorComunicacion porque la operacion
							//anterior puede dar error y si fuese ese el caso
							//mejor no iniciar el timer.
							if (Primero.ErrorComunicacion == false)	Primero.IniciarTimerArduino();
							else Primero.DetenerTimerArduino();
						}
						if (SegundoPuertoAbierto == true && Segundo.ErrorComunicacion == false)
						{
							Segundo.LeerPuerto();
							if (Segundo.ErrorComunicacion == false)	Segundo.IniciarTimerArduino();
							else Segundo.DetenerTimerArduino();
						}
					
						if (TercerPuertoAbierto == true && Tercero.ErrorComunicacion == false)
						{
							//Tercero.LeerPuerto(placa);
							Tercero.LeerPuerto();
						}
					}
				
					if (Primero.ErrorComunicacion == false && Segundo.ErrorComunicacion == false && 
							Tercero.ErrorComunicacion == false)
					//todos los arduinos conectados
					{
						//detengo el timer de Desconeccion
						DeternerTimerDesconeccion();
					}
					
					
					if (Primero.DatosRecibidos == true) // llegaron datos al pto
														// 1
					{
						Primero.DetenerTimerArduino();
						PrimeroPiso = Primero.Analizar();
						Primero.DatosRecibidos = false;
						//for (Cont = 0 + Cont1; Cont < 16 + Cont1; ++Cont)
						for (Cont = 0 ; Cont < 64 ; ++Cont)
						{
							PisosElegidos[Cont] = PrimeroPiso[Cont];
						}
						FlagDatosAmostrarARD1 = true;
						
					}
					
					if (Segundo.DatosRecibidos == true) // llegaron datos al pto
														// 2
					{
						Segundo.DetenerTimerArduino();
						SegundoPiso = Segundo.Analizar();
						Segundo.DatosRecibidos = false;
						
						//for (Cont = 0 + Cont2 + 64; Cont < 16 + Cont2 + 64; ++Cont)
						for (Cont = 64 ; Cont < 112 ; ++Cont)	//solo hasta 112 y no 128 porque los 
																//ultimos 16 son para uso extra
						{
							PisosElegidos[Cont] = SegundoPiso[Cont - 64];
							if (PisosElegidos[Cont] != 0 ) PisosElegidos[Cont] = PisosElegidos[Cont] + 64;
						}
						UbicacionAscensor = Segundo.PoscicionAscensor;	//aca tengo el dato en binario de la poscion del ascensor.
						DireccionAscensor = Segundo.EstadoAscensor;		//en que sentido se desplasa el ascensor
						FlagDatosAmostrarARD2 = true;
						//Cont2 = Cont - 64;
					}
					/*
					if (Tercero.DatosRecibidos == true) // llegaron datos al pto
														// 3
					{
						TerceroPiso = Tercero.Analizar();
						Tercero.DatosRecibidos = false;
						for (Cont = 0 + Cont3 + 128; Cont < 16 + Cont3 + 128; ++Cont)
						{
							PisosElegidos[Cont] = TerceroPiso[Cont - Cont3
									- 128];
						}

						Cont3 = Cont - 128;
					}//*/
					placa = placa + 2;

				} 
				else
				// una vez leidas todas las placas de todos los Arduino se
				// reinicia
				// los contadores y se analiza la informacion a mostrar!

				{
					for (int u = 0; u < 200; ++u)
					{
						for (int i = 0; i < 200 - u; ++i)
						{
							if (PisosElegidos[i] > PisosElegidos[i + 1])
							{
								int Variableintermerdia = PisosElegidos[i];
								PisosElegidos[i] = PisosElegidos[i + 1];
								PisosElegidos[i + 1] = Variableintermerdia;
							}
						}
					}
					/**
					 * En esta parte determino si se pueden mostrar los datos o no
					 * Tengo que hacer que solo se muestren los datos cuando se recibieron los datos
					 * de todos los arduinos conectados
					 */
					
					//TODO 
					//Modificar los datos a mostrar.
					//Que solo muestre los datos cuando los 2 respondieron
					//if (FlagDatosAmostrarARD1 == true || (FlagDatosAmostrarARD1 ==true && FlagDatosAmostrarARD2 == true) ) 
					if (FlagDatosAmostrarARD1 == true && FlagDatosAmostrarARD2 == true) 
					{
					DatosAMostrar = true;
					FlagDatosAmostrarARD1 = false;
					FlagDatosAmostrarARD2 = false;
					FlagDatosAmostrarARD3 = false;
					}
					placa = 1;
					Cont1 = 0;
					Cont2 = 0;
					Cont3 = 0;
					Cont = 0;
					/*for (int u = 0; u < 200; ++u)
						PisosElegidos[u] = 0; // inicializar el vector de los
												// pisos!//*/
				}

			}
			
			

		};// */

		timer = new Timer(periodo, Accion); // Seteo de los valores del timer
	}

	public int[] getterPisos ()
	{
		return PisosElegidos;
	}
	
	public void ResetVariables()
	{
		placa = 1;
		Cont1 = 0;
		Cont2 = 0;
		Cont3 = 0;
		Cont = 0;
		for (int u = 0; u < 200; ++u)
			PisosElegidos[u] = 0; // inicializar el vector de los
									// pisos!
		
	}
	
	
	// ----------------------------------------------------------------------------------------------------------------------------------
	/**
	 * @param tiempo
	 * Timer que contempla un tiempo de respuesta del Arduino.
	 * si no llega la contestacion en un cantidad de tiempo
	 * predefinada, se reenvia el dato hasta obtener la respuesta.
	 */
	public void TemporizadorRespuesta(int tiempo)
	{

		ActionListener Accion1 = new ActionListener()
		{

			/*
			 * Accion a realizar una vez que se activo el timer de contestacion
			 */
			public void actionPerformed(ActionEvent e)
			{
				++contadortimer;
				//System.out.println(contadortimer);
				if (Primero.Contestacion == true
						|| Segundo.Contestacion == true
						|| Tercero.Contestacion == true)
				{
					Primero.Contestacion = false;
					Segundo.Contestacion = false;
					Tercero.Contestacion = false;
					Respuesta.stop();
					contadortimer = 0;
					ultimasalida = 0;
					IniciarTimer();

				}
				if (contadortimer > 10) //Timer overflow .. no contesto. reenviar dato
				{
					System.out.println("Retry");
					EscribirLog.EscribirElArchivo("Error de Comunicacion Reenvio " + ultimasalida);
					EnviarDato(ultimasalida);

				}
				if (contadortimer >20)
				{	
					
					Respuesta.stop();
					contadortimer = 0;
					IniciarTimer();
				}

			}
		};

		Respuesta = new Timer(tiempo, Accion1);
		Respuesta.stop();
	}

	/**
	 * Inicia el Timer de espera de Respuesta del Arduino
	 */
	public void IniciarTimerRespuesta()
	{
		Respuesta.start();
	}

	/**
	 * Detiene el timer de espera de Respuesta del Arduino
	 */
	public void DeternerTimerRespuesta()
	{
		Respuesta.stop();
	}

	// ------------------------------------------------------------------------------------------------------------------------------------
	// Se encarga de hacer el analisis del piso solicitado
	public void EnviarDato(int pisoelegido)
	{
		// timer.cancel();
		boolean SalidaEjecutada = false;
		String Salida = null;
		/*if (pisoelegido <10)
		{
		Salida = "0" + String.valueOf(pisoelegido);
		}
		else 
		{
		Salida = String.valueOf(pisoelegido);	
		}//*/
		int pisoelegidofinal = 0;
		
		if (pisoelegido>64) pisoelegidofinal = pisoelegido - 64;
		else pisoelegidofinal = pisoelegido;
		
		if (pisoelegidofinal <10)
		{
		Salida = "0" + String.valueOf(pisoelegidofinal);
		}
		else 
		{
		Salida = String.valueOf(pisoelegidofinal);	
		}
		
		
			
		ultimasalida = pisoelegido;
		if (pisoelegido <= CantidadPisosARD1 && PrimerPuertoAbierto == true) // es
		// un
		// piso
		// que
		// corresponde
		// al
		// primer
		// controlador
		{
			Primero.EscribirPuerto("ON" + Salida);
			//System.out.println(Salida);
			//System.out.println("Primer arduino " + Salida);
			SalidaEjecutada = true;
			
		}
		if (pisoelegido > CantidadPisosARD1
				&& pisoelegido <= (CantidadPisosARD2 + CantidadPisosARD1)
				&& SegundoPuertoAbierto == true) // es
		// un
		// piso
		// que
		// corresponde
		// al
		// segundo
		// controlador
		{
			/*
			int pisoparaSegundo = Integer.valueOf(Salida) - 64;
			
			if (pisoparaSegundo <10)
			{
			Salida = "0" + String.valueOf(pisoparaSegundo);
			}
			else
			{
			Salida = String.valueOf(pisoparaSegundo);	
			}
			
		
			//pisoelegido = pisoelegido - CantidadPisosARD1;
	//		Salida = String.valueOf(pisoelegido);*/
			Segundo.EscribirPuerto("ON" + Salida); //
			//System.out.println(Salida);
			//System.out.println("Segundo arduino " + Salida);
			SalidaEjecutada = true;
		}
		if (pisoelegido > (CantidadPisosARD1 + CantidadPisosARD2)
				&& pisoelegido <= (CantidadPisosARD3 + CantidadPisosARD2 + CantidadPisosARD1)
				&& TercerPuertoAbierto == true) // es
		// un
		// piso
		// que
		// corresponde
		// al
		// tercer
		// controlador
		{
			//System.out.println("Tercer arduino");
			pisoelegido = pisoelegido - CantidadPisosARD1 - CantidadPisosARD2;
			//String Salida = String.valueOf(pisoelegido);
			Tercero.EscribirPuerto("ON" + Salida);
			SalidaEjecutada = true;
		}
		// clareo las variables usadas y pongo en
		// blanco el texto
		if (SalidaEjecutada == true)
		{
			IniciarTimerRespuesta();
		}
	}
//------------------------------------------------------------------------------------------------------------------------------
	/**
	 * Lee el archivo con la configuracion de salidas de acuerdo a las necesidades.
	 */
	
	public void LeerconfiguracionVectorSalida()
	{
		for(int VincularSalidas=0;VincularSalidas <99; ++VincularSalidas)
		{
			if (LecturaSalidas.LeerArchivoSalidas("Salida"+VincularSalidas) != null)
			{
			VectorSalidas[VincularSalidas] = Integer.valueOf(LecturaSalidas.LeerArchivoSalidas("Salida"+VincularSalidas));
		//	System.out.println(VectorSalidas[VincularSalidas]);
			}
			
		}
	
	
	}
	
//-------------------------------------------------------------------------------------------------------------------------------
	/**
	 * Timer para deshabiliatar la interfaz si no se detecta a los
	 * Arduinos en un determinado tiempo
	 */
	
	public void TemporizadorDesconeccion()
	{
		
		ActionListener AccionDesconeccion = new ActionListener()
		{
			
			/*
			 * EL timer deberia:
			 * Deshabilitar la pantalla principal
			 * dar un aviso de error
			 * Cerrar los puertos
			 */
			public void actionPerformed(ActionEvent e)
			{
				
				CerrarTodosPuertos();
				timerdesconeccion.stop();
				DesconeccionArduino = true;
			}
			
			

		};// */

		timerdesconeccion = new Timer(periododesconeccion, AccionDesconeccion); // Seteo de los valores del timer
		timerdesconeccion.stop();
	}
	
	/**
	 * Inicia el Timer de espera de Respuesta del Arduino
	 */
	public void IniciarTimerDesconeccion()
	{
		timerdesconeccion.start();
	}

	/**
	 * Detiene el timer de espera de Respuesta del Arduino
	 */
	public void DeternerTimerDesconeccion()
	{
		timerdesconeccion.stop();
	}
	
//-----------------------------------------------------------------------------------------------------------------------
	public void CerrarTodosPuertos()
	{
		try
		{
			if (PrimerPuertoAbierto == true)
				Primero.CerrarPuerto();
			if (SegundoPuertoAbierto == true)
				Segundo.CerrarPuerto();
			if (TercerPuertoAbierto == true)
				Tercero.CerrarPuerto();
		} catch (Exception e1)
		{
			e1.printStackTrace();
		}
		//Limpio las banderas de los puertos abiertos
		PrimerPuertoAbierto = false;
		SegundoPuertoAbierto = false;
		TercerPuertoAbierto = false;
	
	}

}
